#ifndef NODO_H
#define NODO_H

#include <iostream>
#include <climits>
#include "elemento_ui.h"

using namespace std;

class Nodo : public Elemento_ui
{
    public:
      /** Costruttore di default */
      Nodo();
      
      /** Costruttore che inizializza le coordinate e l'indice.
       * Le coordinate rappresentano il punto nel quale verrà disegnato il nodo,
       * mentre l'indice identifica univocamente il nodo, viene assegnato alla creazione del nodo e
       * non può essere modificato successivamente.
       * \param x coordinata X
       * \param y coordinata Y
       * \param indice indice univoco del nodo
       */
      Nodo(gdouble x, gdouble y, guint indice) 
      {
          set_x(x);
          set_y(y);
          this->indice = indice;
          set_precedente(NULL);
          set_distanza(G_MININT);
          set_selected(FALSE);
          set_over(FALSE);
          raggio = 25.0;
      }
      
      /** Distruttore di default */
      virtual ~Nodo();
      
      /** Restituisce l'indice del nodo.
       * \return L'indice del nodo
       */
      guint get_indice() { return indice; }
      
      /** Restituisce la distanza del nodo.
       * La distanza restituita è corretta solo dopo l'esecuzione di una delle classi che specializzano ::Algoritmo        
       * \return La distanza del nodo calcolata mediante uno degli algoritmi a disposizione.
       */
      gint get_distanza() { return distanza; }
      
      /** Imposta la distanza del nodo
       * \param val La nuova distanza da assegnare al nodo
       */
      void set_distanza(int val) { distanza = val; }
      
      /** Imposta il nodo a distanza infinita.
       */
      void set_distanza_infinita() { distanza = G_MAXINT; }
      
      /** Restituisce il nodo precedente nel cammino minimo.
       * Il nodo precedente è diverso da NULL solo dopo l'esecuzione di una delle classi che specializzano ::Algoritmo        
       * \return Il ::Nodo precedente nel cammino minimo calcolato
       */
      Nodo* get_precedente() { return precedente; }
      
      /** Imposta il nodo precedente
       * Viene utilizzata dalle classi che specializzano ::Algoritmo per impostare il cammino minimo        
       * \param val ::Nodo precedente
       */
      void set_precedente(Nodo* val) { precedente = val; }
      
      /** Restituisce il raggio del nodo.
       * Utilizzato per la rappresentazione visuale del nodo      
       * @return Il raggio della circonferenza del nodo
       */
      gdouble get_raggio() { return raggio; }

	virtual void update(gdouble x, gdouble y);
	virtual void draw(cairo_t* &cr);
	virtual gboolean intersect(gdouble x, gdouble y);
    protected:
    private:
        guint indice; //!< Indice univoco del nodo
        gint distanza; //!< Distanza del nodo calcolata da uno degli algoritmi disponibili
        Nodo* precedente; //!< Nodo precedente calcolato da uno degli algoritmi disponibili
        gdouble raggio; //!< Raggio del cerchio rappresentante il nodo
};

#endif // NODO_H
